home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / minix / libsrc~1.z / libsrc~1 / sflonum.s < prev    next >
Encoding:
Text File  |  1989-12-28  |  9.2 KB  |  450 lines
  1. |
  2. |    Single Precision Floating point support code.
  3. |
  4. |    A SP float looks like:
  5. |
  6. |    |S|E.x.p ... |M.a.n.t.i.s.s.a ... |
  7. |    +-+----------+--------------------+
  8. |
  9. |    where s is the sign bit, Exp is 8 bits of exponent, interpreted
  10. |    as E + 126, and Mantissa is 23 bits of fraction, with a
  11. |    hidden bit.  The point is to the left of the hidden bit.
  12. |    Doubles have another word of mantissa following.
  13. |
  14. |    All these routines have calling sequences like c routines,
  15. |    ie args on stack in backwards order, return values in d0
  16. |
  17.  
  18. #ifdef L_addsf3
  19.     .text
  20.     .even
  21.     .globl ___addsf3
  22.     .globl __addsf3
  23. ___addsf3:
  24. __addsf3:
  25.     link    a6,#0        | dont need any locals
  26.     moveml    #0x3F00,sp@-    | save all data registers
  27.     movel    a6@(8),d0    | get a
  28.     beq    addsf_ret_b    |  zero .. just return b
  29.     movel    #23,d6        | shift count
  30.     movel    d0,d2        | get the exponent
  31.     lsrl    d6,d2        | and shift right
  32.     andl    #0xFF,d2    | no sign bit
  33.     subl    #126,d2        | offset the exponent
  34.     movel    a6@(12),d1    | get b
  35.     beq    addsf_ret_a
  36.     movel    d1,d3        | get the exponent for b
  37.     lsrl    d6,d3        | and shift right, with implicit extend
  38.     andl    #0xFF,d3    | make sure we didnt get a sign bit
  39.     subl    #126,d3        | off set this one too
  40.  
  41.     andl    #0x7FFFFF,d0    | mask a for mantissa
  42.     orl    #0x800000,d0    | and put in hidden bit
  43.     tstl    a6@(8)        | test the original value
  44.     bpl    addsf_1        | pos, ok
  45.     negl    d0        | neg, negate the mantissa
  46. addsf_1:
  47.     andl    #0x7FFFFF,d1    | mask b for mantissa
  48.     orl    #0x800000,d1    | ditto
  49.     tstl    a6@(12)        | test ...
  50.     bpl    addsf_2
  51.     negl    d1        | negate this one
  52. addsf_2:
  53.     cmpl    d2,d3        | compare Ea to Eb
  54.     blt    addsf_3        | Ea > Eb
  55.  
  56.     movel    d3,d5        | get Eb
  57.     subl    d2,d5        | subtract Ea
  58.     asrl    d5,d0        |  yielding count to shift Ma right
  59.     movel    d3,d5        | use this as resultant exponent
  60.     bra    addsf_4        | and go rejoin common part
  61. addsf_3:
  62.     movel    d2,d5        | get Ea
  63.     subl    d3,d5        | subtract Eb
  64.     asrl    d5,d1        |  yielding count to shift Mb right
  65.     movel    d2,d5        | use this as resultant exponent
  66.  
  67. addsf_4:
  68.     clrl    d7        | zap sign flag
  69.     addl    d1,d0        | add Mb to Ma
  70.  
  71.  
  72.     beq    addsf_z        | zero? ok, go return zero
  73.     bpl    addsf_5        | positive? ok, go scale it
  74.     negl    d0        | negate Mr
  75.     movel    #1,d7        | remember sign
  76. addsf_5:
  77.     btst    #24,d0        | carry?
  78.     beq    addsf_6        | nope, its ok as is
  79.     asrl    #1,d0        | shift right one
  80.     addql    #1,d5        | inc exp
  81.  
  82. | zzz check for overflow in here someplace
  83.  
  84. addsf_6:
  85.     btst    #23,d0        | got a bit in the right place yet?
  86.     bne    addsf_7        | yes, were done
  87.     lsll    #1,d0        | shift left one
  88.     subql    #1,d5        | dec exponent
  89.     bra    addsf_6
  90. addsf_7:
  91.     andl    #0x7FFFFF,d0    | zap out hidden bit
  92.     addl    #126,d5        | add offset to exp
  93.     andl    #0xFF,d5    | zap to 8 bits
  94.     movel    #23,d6        | shift count
  95.     lsll    d6,d5        | shift the exp up
  96.     orl    d5,d0        | stick the exp in
  97.     tstl    d7        | negative?
  98.     beq    addsf_ret_a
  99.     orl    #0x80000000,d0    | yup, negate it
  100.     bra    addsf_ret_a
  101. addsf_z:
  102.     clrl    d0
  103.     bra    addsf_ret_a
  104. addsf_ret_b:
  105.     movel    a6@(12),d0
  106. addsf_ret_a:
  107.     moveml    sp@+,#0x00FC    | snarf back all regs
  108.     unlk    a6
  109.     rts            | sigh
  110. #endif
  111.  
  112. | 
  113. | #ifdef L_negsf2
  114. | int
  115. | _negsf2 (a)
  116. |      union flt_or_int a;
  117. | {
  118. |   union flt_or_int intify;
  119. |   return INTIFY (-a.f);
  120. | }
  121. | #endif
  122.  
  123. #ifdef L_negsf2
  124.     .text
  125.     .even
  126.     .globl ___negsf2
  127.     .globl __negsf2
  128. ___negsf2:
  129. __negsf2:
  130.     movel    sp@(4),d0
  131.     beq    negsf2_z
  132.     eorl    #0x80000000,d0
  133. negsf2_z:
  134.     rts            | sigh
  135. #endif
  136.  
  137. | 
  138. | #ifdef L_subsf3
  139. | int
  140. | _subsf3 (a, b)
  141. |      union flt_or_int a, b;
  142. | {
  143. |   union flt_or_int intify;
  144. |   return INTIFY (a.f - b.f);
  145. | }
  146. | #endif
  147.  
  148. #ifdef L_subsf3
  149.     .text
  150.     .even
  151. .globl ___subsf3
  152. .globl __subsf3
  153. ___subsf3:
  154. __subsf3:
  155.     tstl    sp@(8)        | kludge.  just negate b and add
  156.     beq    subsf_bz    | zero.  dont bother
  157.     eorl    #0x80000000,sp@(8)    | negate it
  158.     jmp    ___addsf3
  159. subsf_bz:
  160.     movel    sp@(4),d0
  161.     rts
  162. #endif
  163.  
  164. | 
  165. | #ifdef L_cmpsf2
  166. | int
  167. | _cmpsf2 (a, b)
  168. |      union flt_or_int a, b;
  169. | {
  170. |   union flt_or_int intify;
  171. |   if (a.f > b.f)
  172. |     return 1;
  173. |   else if (a.f < b.f)
  174. |     return -1;
  175. |   return 0;
  176. | }
  177. | #endif
  178.  
  179. #ifdef L_cmpsf2
  180.     .text
  181.     .even
  182.     .globl ___cmpsf2
  183.     .globl __cmpsf2
  184. ___cmpsf2:
  185. __cmpsf2:
  186.     movel    sp@(4),d0
  187.     movel    sp@(8),d1    | get a hi
  188. |
  189. | crockery.  If both neg and not equal, this algorithm lose.  find a better one!
  190. |
  191.     bpl    cmpsf2_p
  192.     tstl    d0
  193.     bpl    cmpsf2_p
  194.     cmpl    d1,d0
  195.     bgt    cmpsf2_m
  196.     blt    cmpsf2_1
  197.     beq    cmpsf2_z
  198. cmpsf2_p:
  199.     cmpl    d1,d0
  200.     beq    cmpsf2_z
  201.     bgt    cmpsf2_1
  202. cmpsf2_m:
  203.     movel    #-1,d0
  204.     rts
  205. cmpsf2_z:
  206.     clrl    d0
  207.     rts
  208. cmpsf2_1:
  209.     movel    #1,d0
  210.     rts            | sigh
  211. #endif
  212.  
  213. | 
  214. | #ifdef L_mulsf3
  215. | int
  216. | _mulsf3 (a, b)
  217. |      union flt_or_int a, b;
  218. | {
  219. |   union flt_or_int intify;
  220. |   return INTIFY (a.f * b.f);
  221. | }
  222. | #endif
  223.  
  224. #ifdef L_mulsf3
  225.     .text
  226.     .even
  227.     .globl ___mulsf3
  228.     .globl __mulsf3
  229. ___mulsf3:
  230. __mulsf3:
  231. |
  232. | multiply.  take the numbers apart.  shift each exponent down to
  233. | 16 bits.  unsigned multiply those.  shift that down to 24 bits.
  234. | exponent is Ea + Eb.
  235. |
  236.  
  237.     link    a6,#-8        | 64 bit accum for mult
  238.     moveml    #0x3F00,sp@-    | save all data registers
  239.     movel    a6@(8),d0    | get a
  240.     beq    mulsf3_z
  241.     movel    a6@(12),d1    | get b
  242.     beq    mulsf3_z
  243.     movel    #23,d6        | shift count
  244.     movel    d0,d2        | get the exponent
  245.     lsrl    d6,d2        | and shift right
  246.     andl    #0xFF,d2
  247.     subl    #126,d2        | offset the exponent
  248.     movel    d1,d3        | get the exponent for b
  249.     lsrl    d6,d3        | and shift right
  250.     andl    #0xFF,d2
  251.     subl    #126,d3        | off set this one too
  252.  
  253.     clrl    d7        | negative result flag
  254.     andl    #0x7FFFFF,d0    | mask a for mantissa
  255.     orl    #0x800000,d0    | and put in hidden bit
  256.     tstl    a6@(8)        | test the original value
  257.     bpl    mulsf3_1    | pos, ok
  258.     eorl    #1,d7        | remember negative
  259. mulsf3_1:
  260.     andl    #0x7FFFFF,d1    | mask b for mantissa
  261.     orl    #0x800000,d1    | ditto
  262.     tstl    a6@(12)        | test ...
  263.     bpl    mulsf3_2
  264.     eorl    #1,d7
  265. mulsf3_2:
  266. |    lsrl    #8,d1        | shift this one down
  267. |    lsrl    #8,d0        | this one too...
  268. |    mulu    d1,d0        | do the multiply
  269.  
  270. |    beq    mulsf3_ret    | zero? ok, just return
  271. |    lsrl    #8,d0        | shift right again
  272.  
  273. |
  274. | we have mantissas as follows:
  275. |
  276. |    |...ah...|...al...|    |...bh...|...bl...|
  277. |
  278. | product is composed as:
  279. |
  280. |            |....al * bl....|
  281. |        |....al * bh....|
  282. |        |....ah * bl....|
  283. |    |....ah * bh....|
  284. |
  285. | then take the 24 bit chunk thats 16 bits in.
  286.  
  287.     movel    d0,d4
  288.     andl    #0xFFFF,d4    | al
  289.     movel    d1,d5
  290.     andl    #0xFFFF,d5    | bl
  291.     mulu    d5,d4        | thats al * bl
  292.     movel    d4,a6@(-4)    | into the accum
  293.     clrl    a6@(-8)        | zap the top part
  294.  
  295.     movel    d0,d4
  296.     andl    #0xFFFF,d4    | al
  297.     movel    d1,d5
  298.     movel    #16,d6        | shift count
  299.     lsrl    d6,d5        | bh
  300.     mulu    d5,d4        | al * bh
  301.     addl    d4,a6@(-6)
  302.  
  303.     movel    d0,d4
  304.     lsrl    d6,d4        | ah
  305.     movel    d1,d5
  306.     andl    #0xFFFF,d5    | bl
  307.     mulu    d5,d4        | ah * bl
  308.     addl    d4,a6@(-6)
  309.  
  310.     movel    d0,d4
  311.     lsrl    d6,d4        | ah
  312.     movel    d1,d5
  313.     lsrl    d6,d5        | bh
  314.     mulu    d5,d4        | ah * bh
  315.     addl    d4,a6@(-8)
  316.  
  317.     movel    a6@(-6),d0    | get the relevant part
  318.     lsrl    #8,d0        | and shift it down
  319.  
  320. mulsf3_norm:
  321.     btst    #23,d0        | normalized?
  322.     bne    mulsf3_ok
  323.     lsll    #1,d0
  324.     subql    #1,d2
  325.     bra    mulsf3_norm
  326.  
  327. mulsf3_ok:
  328.     andl    #0x7FFFFF,d0    | zap hidden bit
  329.     addl    d3,d2        | add Eb to Ea
  330.     addl    #126,d2        | fix offset
  331.     andl    #0xFF,d2    | whack to 8 bits
  332.     movel    #23,d6        | shift count
  333.     lsll    d6,d2        | shift up to right place
  334.     orl    d2,d0        | shove it in
  335.     tstl    d7        | sign neg?
  336.     beq    mulsf3_ret
  337.     orl    #0x80000000,d0    | set sign bit
  338.     bra    mulsf3_ret
  339. mulsf3_z:
  340.     clrl    d0
  341. mulsf3_ret:
  342.     moveml    sp@+,#0x00FC    | snarf back all regs
  343.     unlk    a6
  344.     rts            | sigh
  345. #endif
  346.  
  347. | 
  348. | #ifdef L_divsf3
  349. | int
  350. | _divsf3 (a, b)
  351. |      union flt_or_int a, b;
  352. | {
  353. |   union flt_or_int intify;
  354. |   return INTIFY (a.f / b.f);
  355. | }
  356. | #endif
  357.  
  358. #ifdef L_divsf3
  359.     .text
  360.     .even
  361.     .globl ___divsf3
  362.     .globl __divsf3
  363. ___divsf3:
  364. __divsf3:
  365. |
  366. | divide.  sort of like mult, exc we do shifts and subtracts to
  367. | do the division of the mantissa.  resultant exponent is Ea - Eb.
  368. |
  369.  
  370.     link    a6,#0        | dont need any locals
  371.     moveml    #0x3F00,sp@-    | save all data registers
  372.     movel    a6@(8),d0    | get a
  373.     movel    a6@(12),d1    | get b
  374.     movel    #23,d6        | shift count
  375.     movel    d0,d2        | get the exponent
  376.     lsrl    d6,d2        | and shift right
  377.     andl    #0xFF,d2
  378.     subl    #127,d2        | offset the exponent
  379.     movel    d1,d3        | get the exponent for b
  380.     lsrl    d6,d3        | and shift right
  381.     andl    #0xFF,d3
  382.     subl    #127,d3        | off set this one too
  383.  
  384.     clrl    d7        | negative result flag
  385.     andl    #0x7FFFFF,d0    | mask a for mantissa
  386.     orl    #0x800000,d0    | and put in hidden bit
  387.     tstl    a6@(8)        | test the original value
  388.     bpl    divsf3_1    | pos, ok
  389.     eorl    #1,d7        | remember negative
  390. divsf3_1:
  391.     andl    #0x7FFFFF,d1    | mask b for mantissa
  392.     orl    #0x800000,d1    | ditto
  393.     tstl    a6@(12)        | test ...
  394.     bpl    divsf3_2
  395.     eorl    #1,d7
  396. divsf3_2:
  397. |
  398. | for now, kludge.  shift Ma left and Mb right, then do an unsigned divide
  399. | and shift the result left.  Blech
  400. |
  401.  
  402. |    lsrl    #8,d1        | shift this one down
  403. |    lsll    #7,d0        | this one up
  404. |    divu    d1,d0        | do the divide
  405. |    andl    #0xFFFF,d0    | and mask off cruft
  406.  
  407. |    beq    divsf3_ret    | zero? ok, just return
  408. |    lsll    #8,d0        | shift left again
  409.  
  410. | same sort of trick as long divide, exc its easier here, cause
  411. | the numbers (mantissas) are already bit-aligned.
  412.  
  413.     clrl    d4        | accumulator
  414.     movel    #0x800000,d5    | bit
  415.     lsll    #7,d0        | buy a little extra accuracy...
  416.     lsll    #7,d1
  417. divsf3_2a:
  418.     cmpl    d1,d0        | compare dividend to divisor
  419.     bmi    divsf3_2b    | nope, no bit here
  420.     orl    d5,d4        | put in the bit
  421.     subl    d1,d0        | and subtract
  422. divsf3_2b:
  423.     lsrl    #1,d1        | slide divisor down
  424.     lsrl    #1,d5        | slide bit down
  425.     bne    divsf3_2a    | and go round again
  426.     movel    d4,d0        | leave the result here
  427.  
  428. divsf3_3:
  429.     btst    #23,d0        | right place yet?
  430.     bne    divsf3_4
  431.     lsll    #1,d0
  432.     subql    #1,d2
  433.     bra    divsf3_3
  434. divsf3_4:
  435.     andl    #0x7FFFFF,d0    | zap hidden bit
  436.     subl    d3,d2        | sub Eb from Ea
  437.     addl    #127,d2        | fix offset
  438.     andl    #0xFF,d2    | whack to 8 bits
  439.     lsll    d6,d2        | shift up to right place
  440.     orl    d2,d0        | shove it in
  441.     tstl    d7        | sign neg?
  442.     beq    divsf3_ret
  443.     orl    #0x80000000,d0    | set sign bit
  444. divsf3_ret:
  445.     moveml    sp@+,#0x00FC    | snarf back all regs
  446.     unlk    a6
  447.  
  448.     rts            | sigh
  449. #endif
  450.